---
title: "控制流 - 条件语句、循环和模式匹配"
description: "学习 Swift 控制流：条件语句、循环、switch 语句和模式匹配，与 JavaScript 对比"
---

# 控制流：条件语句、循环和模式匹配

在本模块中，我们将探索 Swift 的控制流结构，并与 JavaScript 的条件语句和循环进行对比。Swift 提供了强大的控制流功能，包括增强的 switch 语句和模式匹配，比 JavaScript 的 switch 语句更加表达力强。

## 目录

- [条件语句](#条件语句)
- [循环](#循环)
- [Switch 语句](#switch-语句)
- [模式匹配](#模式匹配)
- [控制转移语句](#控制转移语句)
- [错误处理基础](#错误处理基础)
- [练习题](#练习题)
- [关键要点](#关键要点)

## 条件语句

Swift 的条件语句与 JavaScript 类似，但在语法和行为上有一些关键差异。

### If 语句

<UniversalEditor title="If 语句对比" compare={true}>
```javascript !! js
// JavaScript if 语句
let age = 25;
let hasLicense = true;

// 基本 if 语句
if (age >= 18) {
    console.log("你是成年人");
}

// If-else 语句
if (age >= 18) {
    console.log("你可以投票");
} else {
    console.log("你还不能投票");
}

// If-else if-else 链
if (age < 13) {
    console.log("儿童");
} else if (age < 20) {
    console.log("青少年");
} else if (age < 65) {
    console.log("成年人");
} else {
    console.log("老年人");
}

// 带逻辑运算符的条件
if (age >= 18 && hasLicense) {
    console.log("你可以开车");
} else {
    console.log("你不能开车");
}

// 三元运算符
let status = age >= 18 ? "成年人" : "未成年人";
```

```swift !! swift
// Swift if 语句
let age = 25
let hasLicense = true

// 基本 if 语句
if age >= 18 {
    print("你是成年人")
}

// If-else 语句
if age >= 18 {
    print("你可以投票")
} else {
    print("你还不能投票")
}

// If-else if-else 链
if age < 13 {
    print("儿童")
} else if age < 20 {
    print("青少年")
} else if age < 65 {
    print("成年人")
} else {
    print("老年人")
}

// 带逻辑运算符的条件
if age >= 18 && hasLicense {
    print("你可以开车")
} else {
    print("你不能开车")
}

// 三元运算符
let status = age >= 18 ? "成年人" : "未成年人"

// Swift 特有：if 语句中的可选绑定
let optionalName: String? = "John"
if let name = optionalName {
    print("你好，\(name)")
} else {
    print("没有提供姓名")
}

// 多个可选绑定
let optionalAge: Int? = 25
let optionalCity: String? = "New York"
if let age = optionalAge, let city = optionalCity {
    print("\(age) 岁，来自 \(city)")
}
```
</UniversalEditor>

### Guard 语句

Swift 的 guard 语句是一个强大的控制流特性，在 JavaScript 中不存在。

<UniversalEditor title="Guard 语句" compare={true}>
```javascript !! js
// JavaScript: 早期返回模式（相当于 guard）
function processUser(user) {
    // 早期返回进行验证
    if (!user) {
        return "没有提供用户";
    }
    
    if (!user.name) {
        return "用户没有姓名";
    }
    
    if (!user.email) {
        return "用户没有邮箱";
    }
    
    // 主要逻辑在这里
    return `处理用户: ${user.name} (${user.email})`;
}

// 使用
const user1 = { name: "John", email: "john@example.com" };
const user2 = { name: "Jane" };
console.log(processUser(user1)); // "处理用户: John (john@example.com)"
console.log(processUser(user2)); // "用户没有邮箱"
```

```swift !! swift
// Swift guard 语句
func processUser(_ user: [String: Any]?) -> String {
    // Guard 用于早期退出
    guard let user = user else {
        return "没有提供用户"
    }
    
    guard let name = user["name"] as? String else {
        return "用户没有姓名"
    }
    
    guard let email = user["email"] as? String else {
        return "用户没有邮箱"
    }
    
    // 主要逻辑在这里 - user、name 和 email 都可用
    return "处理用户: \(name) (\(email))"
}

// 使用
let user1: [String: Any] = ["name": "John", "email": "john@example.com"]
let user2: [String: Any] = ["name": "Jane"]
print(processUser(user1)) // "处理用户: John (john@example.com)"
print(processUser(user2)) // "用户没有邮箱"

// 带多个条件的 guard
func validateUser(_ user: [String: Any]) -> Bool {
    guard let name = user["name"] as? String,
          let age = user["age"] as? Int,
          age >= 18 else {
        return false
    }
    
    // 所有验证都通过
    return true
}
```
</UniversalEditor>

## 循环

Swift 提供了几种类型的循环，每种都有特定的用例和性能特征。

### For 循环

<UniversalEditor title="For 循环对比" compare={true}>
```javascript !! js
// JavaScript for 循环
let numbers = [1, 2, 3, 4, 5];

// 传统 for 循环
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}

// For...of 循环（遍历值）
for (let number of numbers) {
    console.log(number);
}

// For...in 循环（遍历索引/键）
for (let index in numbers) {
    console.log(`索引 ${index}: ${numbers[index]}`);
}

// ForEach 方法
numbers.forEach((number, index) => {
    console.log(`数字 ${index}: ${number}`);
});

// 基于范围的循环
for (let i = 1; i <= 5; i++) {
    console.log(i);
}

// 遍历对象属性
let person = { name: "John", age: 30, city: "NYC" };
for (let key in person) {
    console.log(`${key}: ${person[key]}`);
}
```

```swift !! swift
// Swift for 循环
let numbers = [1, 2, 3, 4, 5]

// For-in 循环（遍历值）
for number in numbers {
    print(number)
}

// For-in 带索引
for (index, number) in numbers.enumerated() {
    print("索引 \(index): \(number)")
}

// 基于范围的循环
for i in 1...5 {
    print(i)
}

// 半开范围
for i in 1..<5 {
    print(i) // 打印 1, 2, 3, 4
}

// Stride 自定义范围
for i in stride(from: 0, to: 10, by: 2) {
    print(i) // 打印 0, 2, 4, 6, 8
}

// 遍历字典
let person: [String: Any] = ["name": "John", "age": 30, "city": "NYC"]
for (key, value) in person {
    print("\(key): \(value)")
}

// ForEach 方法（函数式方法）
numbers.enumerated().forEach { index, number in
    print("数字 \(index): \(number)")
}

// Swift 特有：for 循环中的 where 子句
for number in numbers where number % 2 == 0 {
    print("偶数: \(number)")
}
```
</UniversalEditor>

### While 和 Repeat-While 循环

<UniversalEditor title="While 循环对比" compare={true}>
```javascript !! js
// JavaScript while 循环
let count = 0;

// While 循环
while (count < 5) {
    console.log(count);
    count++;
}

// Do-while 循环（至少执行一次）
let number = 0;
do {
    console.log(number);
    number++;
} while (number < 3);

// While 循环带 break
let i = 0;
while (true) {
    if (i >= 5) {
        break;
    }
    console.log(i);
    i++;
}

// While 循环带 continue
let j = 0;
while (j < 10) {
    j++;
    if (j % 2 === 0) {
        continue; // 跳过偶数
    }
    console.log(j);
}
```

```swift !! swift
// Swift while 循环
var count = 0

// While 循环
while count < 5 {
    print(count)
    count += 1
}

// Repeat-while 循环（至少执行一次）
var number = 0
repeat {
    print(number)
    number += 1
} while number < 3

// While 循环带 break
var i = 0
while true {
    if i >= 5 {
        break
    }
    print(i)
    i += 1
}

// While 循环带 continue
var j = 0
while j < 10 {
    j += 1
    if j % 2 == 0 {
        continue // 跳过偶数
    }
    print(j)
}

// Swift 特有：带可选绑定的 while 循环
var optionalNumbers: [Int?] = [1, nil, 3, nil, 5]
var index = 0
while index < optionalNumbers.count {
    if let number = optionalNumbers[index] {
        print("找到数字: \(number)")
    }
    index += 1
}
```
</UniversalEditor>

## Switch 语句

Swift 的 switch 语句比 JavaScript 的更加强大，支持模式匹配和复杂条件。

### 基本 Switch 语句

<UniversalEditor title="基本 Switch 语句" compare={true}>
```javascript !! js
// JavaScript switch 语句
let day = "Monday";

switch (day) {
    case "Monday":
        console.log("工作周开始");
        break;
    case "Tuesday":
    case "Wednesday":
    case "Thursday":
        console.log("周中");
        break;
    case "Friday":
        console.log("TGIF!");
        break;
    case "Saturday":
    case "Sunday":
        console.log("周末!");
        break;
    default:
        console.log("无效的日期");
}

// Switch 带 fall-through（显式）
let grade = "B";
switch (grade) {
    case "A":
        console.log("优秀");
        // Fall through
    case "B":
        console.log("良好");
        break;
    case "C":
        console.log("一般");
        break;
    default:
        console.log("需要改进");
}
```

```swift !! swift
// Swift switch 语句
let day = "Monday"

switch day {
case "Monday":
    print("工作周开始")
case "Tuesday", "Wednesday", "Thursday":
    print("周中")
case "Friday":
    print("TGIF!")
case "Saturday", "Sunday":
    print("周末!")
default:
    print("无效的日期")
}

// Switch 带 fallthrough（显式）
let grade = "B"
switch grade {
case "A":
    print("优秀")
    fallthrough
case "B":
    print("良好")
case "C":
    print("一般")
default:
    print("需要改进")
}

// Swift 特有：带范围的 Switch
let score = 85
switch score {
case 90...100:
    print("A")
case 80..<90:
    print("B")
case 70..<80:
    print("C")
case 60..<70:
    print("D")
case 0..<60:
    print("F")
default:
    print("无效分数")
}

// Switch 带元组
let point = (2, 0)
switch point {
case (0, 0):
    print("原点")
case (_, 0):
    print("在 x 轴上")
case (0, _):
    print("在 y 轴上")
case (-2...2, -2...2):
    print("靠近原点")
default:
    print("其他地方")
}
```
</UniversalEditor>

### 高级 Switch 和模式匹配

<UniversalEditor title="高级 Switch 和模式匹配" compare={true}>
```javascript !! js
// JavaScript: 复杂条件逻辑（没有直接等价物）
function processValue(value) {
    if (typeof value === "string") {
        if (value.length === 0) {
            return "空字符串";
        } else if (value.length < 10) {
            return "短字符串";
        } else {
            return "长字符串";
        }
    } else if (typeof value === "number") {
        if (value === 0) {
            return "零";
        } else if (value > 0) {
            return "正数";
        } else {
            return "负数";
        }
    } else if (Array.isArray(value)) {
        if (value.length === 0) {
            return "空数组";
        } else {
            return `包含 ${value.length} 个元素的数组`;
        }
    } else if (value === null) {
        return "空值";
    } else {
        return "未知类型";
    }
}

// 使用
console.log(processValue("hello")); // "短字符串"
console.log(processValue(42)); // "正数"
console.log(processValue([1, 2, 3])); // "包含 3 个元素的数组"
```

```swift !! swift
// Swift: 带模式匹配的高级 switch
func processValue(_ value: Any) -> String {
    switch value {
    case let str as String:
        switch str {
        case "":
            return "空字符串"
        case let s where s.count < 10:
            return "短字符串"
        default:
            return "长字符串"
        }
    case let num as Int:
        switch num {
        case 0:
            return "零"
        case let n where n > 0:
            return "正数"
        default:
            return "负数"
        }
    case let arr as [Any]:
        switch arr {
        case []:
            return "空数组"
        case let a where a.count > 0:
            return "包含 \(a.count) 个元素的数组"
        default:
            return "未知数组"
        }
    case nil:
        return "空值"
    default:
        return "未知类型"
    }
}

// 使用
print(processValue("hello")) // "短字符串"
print(processValue(42)) // "正数"
print(processValue([1, 2, 3])) // "包含 3 个元素的数组"

// 带枚举的 Switch 模式匹配
enum Direction {
    case north, south, east, west
}

func describeDirection(_ direction: Direction) -> String {
    switch direction {
    case .north:
        return "向上"
    case .south:
        return "向下"
    case .east:
        return "向右"
    case .west:
        return "向左"
    }
}

// 带关联值的 Switch
enum Measurement {
    case distance(Double)
    case temperature(Double)
    case weight(Double)
}

func describeMeasurement(_ measurement: Measurement) -> String {
    switch measurement {
    case .distance(let value):
        return "距离: \(value) 米"
    case .temperature(let value):
        return "温度: \(value)°C"
    case .weight(let value):
        return "重量: \(value) 公斤"
    }
}
```
</UniversalEditor>

## 模式匹配

Swift 的模式匹配能力远超 JavaScript 中可用的功能。

### 值绑定和 Where 子句

<UniversalEditor title="值绑定和 Where 子句" compare={true}>
```javascript !! js
// JavaScript: 复杂条件逻辑
function analyzeNumber(num) {
    if (typeof num === "number") {
        if (num === 0) {
            return "零";
        } else if (num > 0 && num < 100) {
            return `小正数: ${num}`;
        } else if (num >= 100 && num < 1000) {
            return `中等正数: ${num}`;
        } else if (num >= 1000) {
            return `大正数: ${num}`;
        } else {
            return `负数: ${num}`;
        }
    }
    return "不是数字";
}

// 复杂对象分析
function analyzePerson(person) {
    if (person && typeof person === "object") {
        const { name, age, city } = person;
        if (name && age && city) {
            if (age < 18) {
                return `${name} 是来自 ${city} 的未成年人`;
            } else if (age >= 18 && age < 65) {
                return `${name} 是来自 ${city} 的成年人`;
            } else {
                return `${name} 是来自 ${city} 的老年人`;
            }
        }
    }
    return "无效的人员数据";
}
```

```swift !! swift
// Swift: 带值绑定的模式匹配
func analyzeNumber(_ num: Int) -> String {
    switch num {
    case 0:
        return "零"
    case let n where n > 0 && n < 100:
        return "小正数: \(n)"
    case let n where n >= 100 && n < 1000:
        return "中等正数: \(n)"
    case let n where n >= 1000:
        return "大正数: \(n)"
    case let n where n < 0:
        return "负数: \(n)"
    default:
        return "意外情况"
    }
}

// 复杂元组模式匹配
func analyzePerson(_ person: (name: String, age: Int, city: String)) -> String {
    switch person {
    case let (name, age, city) where age < 18:
        return "\(name) 是来自 \(city) 的未成年人"
    case let (name, age, city) where age >= 18 && age < 65:
        return "\(name) 是来自 \(city) 的成年人"
    case let (name, age, city) where age >= 65:
        return "\(name) 是来自 \(city) 的老年人"
    default:
        return "无效的人员数据"
    }
}

// 数组模式匹配
func analyzeArray(_ array: [Int]) -> String {
    switch array {
    case []:
        return "空数组"
    case [let first]:
        return "单个元素: \(first)"
    case [let first, let second]:
        return "两个元素: \(first), \(second)"
    case let arr where arr.count > 2:
        return "包含 \(arr.count) 个元素的数组"
    default:
        return "未知数组"
    }
}

// 可选类型模式匹配
func analyzeOptional(_ value: Int?) -> String {
    switch value {
    case nil:
        return "没有值"
    case let num? where num > 0:
        return "正数: \(num)"
    case let num? where num < 0:
        return "负数: \(num)"
    case 0?:
        return "零"
    default:
        return "意外情况"
    }
}
```
</UniversalEditor>

## 控制转移语句

Swift 提供了几种控制转移语句来管理程序流程。

### Break、Continue 和 Fallthrough

<UniversalEditor title="控制转移语句" compare={true}>
```javascript !! js
// JavaScript 控制转移
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 循环中的 break
for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] === 5) {
        break; // 找到 5 时退出循环
    }
    console.log(numbers[i]);
}

// 循环中的 continue
for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 === 0) {
        continue; // 跳过偶数
    }
    console.log(numbers[i]);
}

// Switch 中的 break（显式）
let day = "Monday";
switch (day) {
    case "Monday":
        console.log("周开始");
        break; // 需要显式 break
    case "Friday":
        console.log("周结束");
        break;
    default:
        console.log("周中");
}

// 标记语句
outerLoop: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (i === 1 && j === 1) {
            break outerLoop; // 跳出外层循环
        }
        console.log(`i=${i}, j=${j}`);
    }
}
```

```swift !! swift
// Swift 控制转移
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// 循环中的 break
for number in numbers {
    if number == 5 {
        break // 找到 5 时退出循环
    }
    print(number)
}

// 循环中的 continue
for number in numbers {
    if number % 2 == 0 {
        continue // 跳过偶数
    }
    print(number)
}

// Switch 中的 break（隐式，无 fallthrough）
let day = "Monday"
switch day {
case "Monday":
    print("周开始")
    // 不需要 break，隐式
case "Friday":
    print("周结束")
default:
    print("周中")
}

// Fallthrough（显式）
let grade = "A"
switch grade {
case "A":
    print("优秀")
    fallthrough // 显式 fallthrough
case "B":
    print("良好")
case "C":
    print("一般")
default:
    print("需要改进")
}

// 标记语句
outerLoop: for i in 0..<3 {
    for j in 0..<3 {
        if i == 1 && j == 1 {
            break outerLoop // 跳出外层循环
        }
        print("i=\(i), j=\(j)")
    }
}

// Swift 特有：带值的 break（在 switch 中）
enum Result {
    case success(String)
    case failure(String)
}

func processResult(_ result: Result) -> String {
    switch result {
    case .success(let message):
        return "成功: \(message)"
    case .failure(let error):
        return "错误: \(error)"
    }
}
```
</UniversalEditor>

## 错误处理基础

Swift 的错误处理比 JavaScript 的 try-catch 更加结构化。

<UniversalEditor title="错误处理对比" compare={true}>
```javascript !! js
// JavaScript 错误处理
function divideNumbers(a, b) {
    if (b === 0) {
        throw new Error("除零错误");
    }
    return a / b;
}

// Try-catch
try {
    const result = divideNumbers(10, 0);
    console.log(result);
} catch (error) {
    console.log("错误:", error.message);
}

// Try-catch with finally
try {
    const result = divideNumbers(10, 2);
    console.log("结果:", result);
} catch (error) {
    console.log("错误:", error.message);
} finally {
    console.log("清理完成");
}

// 自定义错误类型
class ValidationError extends Error {
    constructor(message) {
        super(message);
        this.name = "ValidationError";
    }
}

function validateAge(age) {
    if (age < 0) {
        throw new ValidationError("年龄不能为负数");
    }
    if (age > 150) {
        throw new ValidationError("年龄似乎不现实");
    }
    return true;
}
```

```swift !! swift
// Swift 错误处理
enum DivisionError: Error {
    case divisionByZero
    case invalidInput
}

func divideNumbers(_ a: Double, _ b: Double) throws -> Double {
    guard b != 0 else {
        throw DivisionError.divisionByZero
    }
    return a / b
}

// Do-catch
do {
    let result = try divideNumbers(10, 0)
    print(result)
} catch DivisionError.divisionByZero {
    print("错误: 除零错误")
} catch {
    print("错误: \(error)")
}

// Try with 可选绑定
if let result = try? divideNumbers(10, 2) {
    print("结果: \(result)")
} else {
    print("发生错误")
}

// Force try（如果错误会崩溃）
let result = try! divideNumbers(10, 2) // 这里安全

// 自定义错误类型
enum ValidationError: Error {
    case negativeAge
    case unrealisticAge(Int)
    case missingName
}

func validateAge(_ age: Int) throws {
    if age < 0 {
        throw ValidationError.negativeAge
    }
    if age > 150 {
        throw ValidationError.unrealisticAge(age)
    }
}

func validatePerson(name: String?, age: Int) throws {
    guard let name = name, !name.isEmpty else {
        throw ValidationError.missingName
    }
    try validateAge(age)
    print("有效人员: \(name)，年龄 \(age)")
}

// 带模式匹配的错误处理
do {
    try validatePerson(name: nil, age: 25)
} catch ValidationError.negativeAge {
    print("年龄不能为负数")
} catch ValidationError.unrealisticAge(let age) {
    print("年龄 \(age) 似乎不现实")
} catch ValidationError.missingName {
    print("需要姓名")
} catch {
    print("未知错误: \(error)")
}
```
</UniversalEditor>

## 练习题

### 练习 1：成绩计算器
创建一个函数，接受分数并使用 switch 语句返回等级。

<UniversalEditor title="练习 1 解答" compare={true}>
```javascript !! js
// JavaScript 解答
function getGrade(score) {
    switch (true) {
        case score >= 90:
            return "A";
        case score >= 80:
            return "B";
        case score >= 70:
            return "C";
        case score >= 60:
            return "D";
        case score >= 0:
            return "F";
        default:
            return "无效分数";
    }
}

// 测试
console.log(getGrade(95)); // "A"
console.log(getGrade(85)); // "B"
console.log(getGrade(75)); // "C"
console.log(getGrade(65)); // "D"
console.log(getGrade(55)); // "F"
```

```swift !! swift
// Swift 解答
func getGrade(_ score: Int) -> String {
    switch score {
    case 90...100:
        return "A"
    case 80..<90:
        return "B"
    case 70..<80:
        return "C"
    case 60..<70:
        return "D"
    case 0..<60:
        return "F"
    default:
        return "无效分数"
    }
}

// 测试
print(getGrade(95)) // "A"
print(getGrade(85)) // "B"
print(getGrade(75)) // "C"
print(getGrade(65)) // "D"
print(getGrade(55)) // "F"
```
</UniversalEditor>

### 练习 2：数字分析器
创建一个函数，使用模式匹配分析数字并返回描述。

<UniversalEditor title="练习 2 解答" compare={true}>
```javascript !! js
// JavaScript 解答
function analyzeNumber(num) {
    if (typeof num !== "number") {
        return "不是数字";
    }
    
    if (num === 0) {
        return "零";
    } else if (num > 0) {
        if (num % 2 === 0) {
            return "正偶数";
        } else {
            return "正奇数";
        }
    } else {
        if (num % 2 === 0) {
            return "负偶数";
        } else {
            return "负奇数";
        }
    }
}

// 测试
console.log(analyzeNumber(0)); // "零"
console.log(analyzeNumber(4)); // "正偶数"
console.log(analyzeNumber(7)); // "正奇数"
console.log(analyzeNumber(-2)); // "负偶数"
console.log(analyzeNumber(-3)); // "负奇数"
```

```swift !! swift
// Swift 解答
func analyzeNumber(_ num: Int) -> String {
    switch num {
    case 0:
        return "零"
    case let n where n > 0 && n % 2 == 0:
        return "正偶数"
    case let n where n > 0 && n % 2 != 0:
        return "正奇数"
    case let n where n < 0 && n % 2 == 0:
        return "负偶数"
    case let n where n < 0 && n % 2 != 0:
        return "负奇数"
    default:
        return "意外情况"
    }
}

// 测试
print(analyzeNumber(0)) // "零"
print(analyzeNumber(4)) // "正偶数"
print(analyzeNumber(7)) // "正奇数"
print(analyzeNumber(-2)) // "负偶数"
print(analyzeNumber(-3)) // "负奇数"
```
</UniversalEditor>

### 练习 3：数组处理器
创建一个函数，使用不同的控制流模式处理数组。

<UniversalEditor title="练习 3 解答" compare={true}>
```javascript !! js
// JavaScript 解答
function processArray(arr) {
    if (!Array.isArray(arr)) {
        return "不是数组";
    }
    
    if (arr.length === 0) {
        return "空数组";
    }
    
    let sum = 0;
    let hasNegative = false;
    let hasPositive = false;
    
    for (let num of arr) {
        if (typeof num !== "number") {
            continue; // 跳过非数字
        }
        
        sum += num;
        
        if (num < 0) {
            hasNegative = true;
        } else if (num > 0) {
            hasPositive = true;
        }
    }
    
    if (hasNegative && hasPositive) {
        return "混合数组，总和: " + sum;
    } else if (hasPositive) {
        return "全正数，总和: " + sum;
    } else if (hasNegative) {
        return "全负数，总和: " + sum;
    } else {
        return "全零，总和: " + sum;
    }
}

// 测试
console.log(processArray([1, 2, 3])); // "全正数，总和: 6"
console.log(processArray([-1, -2, -3])); // "全负数，总和: -6"
console.log(processArray([1, -2, 3])); // "混合数组，总和: 2"
console.log(processArray([0, 0, 0])); // "全零，总和: 0"
```

```swift !! swift
// Swift 解答
func processArray(_ arr: [Any]) -> String {
    switch arr {
    case []:
        return "空数组"
    case let array where array.allSatisfy({ $0 is Int }):
        let numbers = array.compactMap { $0 as? Int }
        let sum = numbers.reduce(0, +)
        
        let hasNegative = numbers.contains { $0 < 0 }
        let hasPositive = numbers.contains { $0 > 0 }
        
        switch (hasNegative, hasPositive) {
        case (true, true):
            return "混合数组，总和: \(sum)"
        case (false, true):
            return "全正数，总和: \(sum)"
        case (true, false):
            return "全负数，总和: \(sum)"
        case (false, false):
            return "全零，总和: \(sum)"
        }
    default:
        return "不是数字数组"
    }
}

// 使用 guard 的替代方法
func processArrayWithGuard(_ arr: [Any]) -> String {
    guard !arr.isEmpty else {
        return "空数组"
    }
    
    var sum = 0
    var hasNegative = false
    var hasPositive = false
    
    for element in arr {
        guard let num = element as? Int else {
            continue // 跳过非数字
        }
        
        sum += num
        
        if num < 0 {
            hasNegative = true
        } else if num > 0 {
            hasPositive = true
        }
    }
    
    if hasNegative && hasPositive {
        return "混合数组，总和: \(sum)"
    } else if hasPositive {
        return "全正数，总和: \(sum)"
    } else if hasNegative {
        return "全负数，总和: \(sum)"
    } else {
        return "全零，总和: \(sum)"
    }
}

// 测试
print(processArray([1, 2, 3])) // "全正数，总和: 6"
print(processArray([-1, -2, -3])) // "全负数，总和: -6"
print(processArray([1, -2, 3])) // "混合数组，总和: 2"
print(processArray([0, 0, 0])) // "全零，总和: 0"
```
</UniversalEditor>

## 关键要点

### Swift 控制流优势
1. **模式匹配**：强大的 switch 语句，支持复杂模式匹配
2. **Guard 语句**：早期退出模式，代码更清晰
3. **值绑定**：直接在 switch case 中提取值
4. **Where 子句**：模式匹配中的附加条件
5. **穷尽匹配**：编译器确保处理所有情况

### 与 JavaScript 的关键差异
1. **Switch 语句**：功能更强大，支持模式匹配
2. **Guard 语句**：JavaScript 中没有等价物
3. **Fallthrough**：switch 语句中显式 vs 隐式
4. **错误处理**：结构化的 try-catch 和 do-catch 块
5. **模式匹配**：JavaScript 中不可用的高级匹配功能

### 最佳实践
1. **使用 guard 语句**进行早期验证和退出
2. **在 switch 语句中利用模式匹配**
3. **优先使用 switch 而不是 if-else 链**处理多个条件
4. **使用 where 子句**进行附加过滤
5. **在 switch 语句中处理所有情况**
6. **使用结构化的错误处理**和 do-catch 块

### 下一步
在下一个模块中，我们将探索 Swift 中的类和结构体，包括面向对象编程概念、继承以及值类型和引用类型之间的差异。这将建立在我们对控制流的理解基础上，展示如何将代码组织成可重用的组件。 